
struct-yz.o:     file format elf64-littleaarch64


Disassembly of section .text:

0000000000000000 <test>:
	int c;
	struct tt t;
};

int test(struct tt *ts)
{
   0:	a9bd7bfd 	stp	x29, x30, [sp, #-48]!
   4:	910003fd 	mov	x29, sp
   8:	f9000fa0 	str	x0, [x29, #24]
//	struct tt *t;
	struct wd *w;
	char *p;
	
	ts->a = 'a';
   c:	f9400fa0 	ldr	x0, [x29, #24]
  10:	52800c21 	mov	w1, #0x61                  	// #97
  14:	39000001 	strb	w1, [x0]
	ts->private_data = "wiaozhi_1234567890";
  18:	f9400fa0 	ldr	x0, [x29, #24]
  1c:	90000001 	adrp	x1, 0 <test>
  20:	91000021 	add	x1, x1, #0x0
  24:	f9000401 	str	x1, [x0, #8]
	
	//w = (struct wd *)t->private_data;
	w = ts->private_data;
  28:	f9400fa0 	ldr	x0, [x29, #24]
  2c:	f9400400 	ldr	x0, [x0, #8]
  30:	f90017a0 	str	x0, [x29, #40]
	p = ts->private_data;
  34:	f9400fa0 	ldr	x0, [x29, #24]
  38:	f9400400 	ldr	x0, [x0, #8]
  3c:	f90013a0 	str	x0, [x29, #32]
	
	//							wiao   zhi_ 1234  567890
	//							w      z    1     5      wiaozhi_1234567890
	printf("%c %c %c %c %s\n", w->a, w->b, w->c, w->t.a, p);
  40:	f94017a0 	ldr	x0, [x29, #40]
  44:	39400000 	ldrb	w0, [x0]
  48:	2a0003e6 	mov	w6, w0
  4c:	f94017a0 	ldr	x0, [x29, #40]
  50:	b9400401 	ldr	w1, [x0, #4]
  54:	f94017a0 	ldr	x0, [x29, #40]
  58:	b9400802 	ldr	w2, [x0, #8]
  5c:	f94017a0 	ldr	x0, [x29, #40]
  60:	39404000 	ldrb	w0, [x0, #16]
  64:	2a0003e3 	mov	w3, w0
  68:	90000000 	adrp	x0, 0 <test>
  6c:	91000000 	add	x0, x0, #0x0
  70:	f94013a5 	ldr	x5, [x29, #32]
  74:	2a0303e4 	mov	w4, w3
  78:	2a0203e3 	mov	w3, w2
  7c:	2a0103e2 	mov	w2, w1
  80:	2a0603e1 	mov	w1, w6
  84:	94000000 	bl	0 <printf>
	
	return 0;
  88:	52800000 	mov	w0, #0x0                   	// #0
}
  8c:	a8c37bfd 	ldp	x29, x30, [sp], #48
  90:	d65f03c0 	ret

0000000000000094 <f>:

int (*pf)(void);

int f(void)
{
  94:	a9bf7bfd 	stp	x29, x30, [sp, #-16]!
  98:	910003fd 	mov	x29, sp
	printf("================= wise\n");
  9c:	90000000 	adrp	x0, 0 <test>
  a0:	91000000 	add	x0, x0, #0x0
  a4:	94000000 	bl	0 <puts>
	return 1;
  a8:	52800020 	mov	w0, #0x1                   	// #1
}
  ac:	a8c17bfd 	ldp	x29, x30, [sp], #16
  b0:	d65f03c0 	ret

00000000000000b4 <test_pf>:

void test_pf()
{
  b4:	a9bf7bfd 	stp	x29, x30, [sp, #-16]!
  b8:	910003fd 	mov	x29, sp
	pf = &f;
  bc:	90000000 	adrp	x0, 8 <test+0x8>
  c0:	91000000 	add	x0, x0, #0x0
  c4:	90000001 	adrp	x1, 94 <f>
  c8:	91000021 	add	x1, x1, #0x0
  cc:	f9000001 	str	x1, [x0]
	pf();
  d0:	90000000 	adrp	x0, 8 <test+0x8>
  d4:	91000000 	add	x0, x0, #0x0
  d8:	f9400000 	ldr	x0, [x0]
  dc:	d63f0000 	blr	x0
	pf = ****f;
  e0:	90000000 	adrp	x0, 8 <test+0x8>
  e4:	91000000 	add	x0, x0, #0x0
  e8:	90000001 	adrp	x1, 94 <f>
  ec:	91000021 	add	x1, x1, #0x0
  f0:	f9000001 	str	x1, [x0]
	pf();
  f4:	90000000 	adrp	x0, 8 <test+0x8>
  f8:	91000000 	add	x0, x0, #0x0
  fc:	f9400000 	ldr	x0, [x0]
 100:	d63f0000 	blr	x0
	(***************************************************f)();
 104:	94000000 	bl	94 <f>
}
 108:	d503201f 	nop
 10c:	a8c17bfd 	ldp	x29, x30, [sp], #16
 110:	d65f03c0 	ret

0000000000000114 <re>:
int re()
{
 114:	d10043ff 	sub	sp, sp, #0x10
	return ((int []){1,2,3,4})[3];
 118:	52800020 	mov	w0, #0x1                   	// #1
 11c:	b90003e0 	str	w0, [sp]
 120:	52800040 	mov	w0, #0x2                   	// #2
 124:	b90007e0 	str	w0, [sp, #4]
 128:	52800060 	mov	w0, #0x3                   	// #3
 12c:	b9000be0 	str	w0, [sp, #8]
 130:	52800080 	mov	w0, #0x4                   	// #4
 134:	b9000fe0 	str	w0, [sp, #12]
 138:	b9400fe0 	ldr	w0, [sp, #12]
}
 13c:	910043ff 	add	sp, sp, #0x10
 140:	d65f03c0 	ret

0000000000000144 <foo>:

unsigned long foo()
{
	return (unsigned long) - 1 / 8;		// 536870911
 144:	92fc0000 	mov	x0, #0x1fffffffffffffff    	// #2305843009213693951
}
 148:	d65f03c0 	ret

000000000000014c <foo2>:

unsigned long foo2()
{
	return ((unsigned long) - 1) / 8;	// 536870911
 14c:	92fc0000 	mov	x0, #0x1fffffffffffffff    	// #2305843009213693951
}
 150:	d65f03c0 	ret

0000000000000154 <foo3>:

unsigned long foo3()
{
	return (unsigned long) (-1 / 8);	// 0
 154:	d2800000 	mov	x0, #0x0                   	// #0
}
 158:	d65f03c0 	ret

000000000000015c <T>:
				((char *)&((T3) {1, (char *) 1}))
			}
		};
		
int T()
{
 15c:	a9bc7bfd 	stp	x29, x30, [sp, #-64]!
 160:	910003fd 	mov	x29, sp
 164:	f9000bf3 	str	x19, [sp, #16]
	T3 *pt3 = (T3*)a[0].value;
 168:	90000000 	adrp	x0, 10 <test+0x10>
 16c:	91000000 	add	x0, x0, #0x0
 170:	f9400400 	ldr	x0, [x0, #8]
 174:	f9001fa0 	str	x0, [x29, #56]
	int value;
	char *b = "xiaozhi";
 178:	90000000 	adrp	x0, 0 <test>
 17c:	91000000 	add	x0, x0, #0x0
 180:	f9001ba0 	str	x0, [x29, #48]
	char c[] = {'a', 'b', 'c', 'd', 'e', 'f'};
 184:	90000000 	adrp	x0, 0 <test>
 188:	91000001 	add	x1, x0, #0x0
 18c:	910083a0 	add	x0, x29, #0x20
 190:	b9400022 	ldr	w2, [x1]
 194:	b9000002 	str	w2, [x0]
 198:	b8402021 	ldur	w1, [x1, #2]
 19c:	b8002001 	stur	w1, [x0, #2]
	
	value = sizeof(a);
 1a0:	52800200 	mov	w0, #0x10                  	// #16
 1a4:	b9002fa0 	str	w0, [x29, #44]
	printf("T() : %d %d %d %d sizeof c=%d strlen c=%d\n", 
 1a8:	f9401ba0 	ldr	x0, [x29, #48]
 1ac:	94000000 	bl	0 <strlen>
 1b0:	aa0003f3 	mov	x19, x0
 1b4:	910083a0 	add	x0, x29, #0x20
 1b8:	94000000 	bl	0 <strlen>
 1bc:	aa0003e1 	mov	x1, x0
 1c0:	90000000 	adrp	x0, 0 <test>
 1c4:	91000000 	add	x0, x0, #0x0
 1c8:	aa0103e6 	mov	x6, x1
 1cc:	d28000c5 	mov	x5, #0x6                   	// #6
 1d0:	aa1303e4 	mov	x4, x19
 1d4:	d2800103 	mov	x3, #0x8                   	// #8
 1d8:	d2800102 	mov	x2, #0x8                   	// #8
 1dc:	b9402fa1 	ldr	w1, [x29, #44]
 1e0:	94000000 	bl	0 <printf>
					 value, sizeof(long),
					 sizeof(b), strlen(b), 
					 sizeof(c), strlen(c));
	return (int)pt3->value;
 1e4:	f9401fa0 	ldr	x0, [x29, #56]
 1e8:	f9400400 	ldr	x0, [x0, #8]
}
 1ec:	f9400bf3 	ldr	x19, [sp, #16]
 1f0:	a8c47bfd 	ldp	x29, x30, [sp], #64
 1f4:	d65f03c0 	ret

00000000000001f8 <fxxx>:
/********************************************************************/

int xxx = 7;
int fxxx()
{
 1f8:	d10043ff 	sub	sp, sp, #0x10
	int xxx = 3;
 1fc:	52800060 	mov	w0, #0x3                   	// #3
 200:	b9000fe0 	str	w0, [sp, #12]
	{
		extern int xxx;
		return xxx;
 204:	90000000 	adrp	x0, 20 <test+0x20>
 208:	91000000 	add	x0, x0, #0x0
 20c:	b9400000 	ldr	w0, [x0]
	}
}
 210:	910043ff 	add	sp, sp, #0x10
 214:	d65f03c0 	ret

0000000000000218 <iii>:

int iii()
{
	return (unsigned long)((1 - sizeof(int)) >> 31);
 218:	12800000 	mov	w0, #0xffffffff            	// #-1
}
 21c:	d65f03c0 	ret

0000000000000220 <print_ix>:
		int y, z;
	}nested;
} ix = { .nested.y = 5, 6, .x = 1, 2};

void print_ix()
{
 220:	a9bf7bfd 	stp	x29, x30, [sp, #-16]!
 224:	910003fd 	mov	x29, sp
	printf("ix.nested.y = %d, ix.nested.x = %d, ix.x = %d\n", ix.nested.y, ix.nested.z, 0);
 228:	90000000 	adrp	x0, 28 <test+0x28>
 22c:	91000000 	add	x0, x0, #0x0
 230:	b9400401 	ldr	w1, [x0, #4]
 234:	90000000 	adrp	x0, 28 <test+0x28>
 238:	91000000 	add	x0, x0, #0x0
 23c:	b9400802 	ldr	w2, [x0, #8]
 240:	90000000 	adrp	x0, 0 <test>
 244:	91000000 	add	x0, x0, #0x0
 248:	52800003 	mov	w3, #0x0                   	// #0
 24c:	94000000 	bl	0 <printf>
}
 250:	d503201f 	nop
 254:	a8c17bfd 	ldp	x29, x30, [sp], #16
 258:	d65f03c0 	ret

000000000000025c <invoke>:

void invoke()
{
 25c:	a9bf7bfd 	stp	x29, x30, [sp, #-16]!
 260:	910003fd 	mov	x29, sp
	printf("invoke re   ======== %d\n",  re());
 264:	94000000 	bl	114 <re>
 268:	2a0003e1 	mov	w1, w0
 26c:	90000000 	adrp	x0, 0 <test>
 270:	91000000 	add	x0, x0, #0x0
 274:	94000000 	bl	0 <printf>
	printf("invoke foo  ======== %ld\n", foo());
 278:	94000000 	bl	144 <foo>
 27c:	aa0003e1 	mov	x1, x0
 280:	90000000 	adrp	x0, 0 <test>
 284:	91000000 	add	x0, x0, #0x0
 288:	94000000 	bl	0 <printf>
	printf("invoke foo2 ======== %ld\n", foo2());
 28c:	94000000 	bl	14c <foo2>
 290:	aa0003e1 	mov	x1, x0
 294:	90000000 	adrp	x0, 0 <test>
 298:	91000000 	add	x0, x0, #0x0
 29c:	94000000 	bl	0 <printf>
	printf("invoke foo3 ======== %ld\n", foo3());
 2a0:	94000000 	bl	154 <foo3>
 2a4:	aa0003e1 	mov	x1, x0
 2a8:	90000000 	adrp	x0, 0 <test>
 2ac:	91000000 	add	x0, x0, #0x0
 2b0:	94000000 	bl	0 <printf>
	printf("invoke T    ======== %d\n", T());
 2b4:	94000000 	bl	15c <T>
 2b8:	2a0003e1 	mov	w1, w0
 2bc:	90000000 	adrp	x0, 0 <test>
 2c0:	91000000 	add	x0, x0, #0x0
 2c4:	94000000 	bl	0 <printf>
	printf("invoke iii    ======== %d\n", iii());
 2c8:	94000000 	bl	218 <iii>
 2cc:	2a0003e1 	mov	w1, w0
 2d0:	90000000 	adrp	x0, 0 <test>
 2d4:	91000000 	add	x0, x0, #0x0
 2d8:	94000000 	bl	0 <printf>
	printf("invoke fxxx    ======== %d\n", fxxx());
 2dc:	94000000 	bl	1f8 <fxxx>
 2e0:	2a0003e1 	mov	w1, w0
 2e4:	90000000 	adrp	x0, 0 <test>
 2e8:	91000000 	add	x0, x0, #0x0
 2ec:	94000000 	bl	0 <printf>
	print_ix();
 2f0:	94000000 	bl	220 <print_ix>
}
 2f4:	d503201f 	nop
 2f8:	a8c17bfd 	ldp	x29, x30, [sp], #16
 2fc:	d65f03c0 	ret

0000000000000300 <saaa>:

int saaa()
{
 300:	a9bc7bfd 	stp	x29, x30, [sp, #-64]!
 304:	910003fd 	mov	x29, sp
	struct tt t;
	struct wd w;
	int value;
	
	test(&t);
 308:	9100c3a0 	add	x0, x29, #0x30
 30c:	94000000 	bl	0 <test>
	test_pf();
 310:	94000000 	bl	b4 <test_pf>
	(***************************test_pf)();
 314:	94000000 	bl	b4 <test_pf>
	invoke();
 318:	94000000 	bl	25c <invoke>
	
	return 0;
 31c:	52800000 	mov	w0, #0x0                   	// #0
}
 320:	a8c47bfd 	ldp	x29, x30, [sp], #64
 324:	d65f03c0 	ret

0000000000000328 <sbbb>:
	short flag;
	dataset data[6];
}frame;

int sbbb(void)
{
 328:	a9b07bfd 	stp	x29, x30, [sp, #-256]!
 32c:	910003fd 	mov	x29, sp
	int i, j, k;
	char *ptr;
	
	frame *pfr;
	
	printf("struct size %d\n", sizeof(pfr));
 330:	90000000 	adrp	x0, 0 <test>
 334:	91000000 	add	x0, x0, #0x0
 338:	d2800101 	mov	x1, #0x8                   	// #8
 33c:	94000000 	bl	0 <printf>
	
	for (i = 0; i < 100; i++) {
 340:	b900ffbf 	str	wzr, [x29, #252]
 344:	1400000b 	b	370 <sbbb+0x48>
		data[i] = i + 1;
 348:	b940ffa0 	ldr	w0, [x29, #252]
 34c:	53001c00 	uxtb	w0, w0
 350:	11000400 	add	w0, w0, #0x1
 354:	53001c02 	uxtb	w2, w0
 358:	b980ffa0 	ldrsw	x0, [x29, #252]
 35c:	910043a1 	add	x1, x29, #0x10
 360:	38206822 	strb	w2, [x1, x0]
	for (i = 0; i < 100; i++) {
 364:	b940ffa0 	ldr	w0, [x29, #252]
 368:	11000400 	add	w0, w0, #0x1
 36c:	b900ffa0 	str	w0, [x29, #252]
 370:	b940ffa0 	ldr	w0, [x29, #252]
 374:	71018c1f 	cmp	w0, #0x63
 378:	54fffe8d 	b.le	348 <sbbb+0x20>
	}
	
	k = 0;
 37c:	b900f7bf 	str	wzr, [x29, #244]
	for (i = 0; i < 6; i++) {
 380:	b900ffbf 	str	wzr, [x29, #252]
 384:	1400001e 	b	3fc <sbbb+0xd4>
		for (j = 0; j < 16; j++) {
 388:	b900fbbf 	str	wzr, [x29, #248]
 38c:	14000016 	b	3e4 <sbbb+0xbc>
			ft.data[i].data[j] = data[k];
 390:	b980f7a0 	ldrsw	x0, [x29, #244]
 394:	910043a1 	add	x1, x29, #0x10
 398:	38606823 	ldrb	w3, [x1, x0]
 39c:	b980fba2 	ldrsw	x2, [x29, #248]
 3a0:	b980ffa1 	ldrsw	x1, [x29, #252]
 3a4:	aa0103e0 	mov	x0, x1
 3a8:	d37df000 	lsl	x0, x0, #3
 3ac:	8b010000 	add	x0, x0, x1
 3b0:	d37ff800 	lsl	x0, x0, #1
 3b4:	910403a1 	add	x1, x29, #0x100
 3b8:	8b000020 	add	x0, x1, x0
 3bc:	8b020000 	add	x0, x0, x2
 3c0:	d1400400 	sub	x0, x0, #0x1, lsl #12
 3c4:	2a0303e1 	mov	w1, w3
 3c8:	393de801 	strb	w1, [x0, #3962]
			k++;
 3cc:	b940f7a0 	ldr	w0, [x29, #244]
 3d0:	11000400 	add	w0, w0, #0x1
 3d4:	b900f7a0 	str	w0, [x29, #244]
		for (j = 0; j < 16; j++) {
 3d8:	b940fba0 	ldr	w0, [x29, #248]
 3dc:	11000400 	add	w0, w0, #0x1
 3e0:	b900fba0 	str	w0, [x29, #248]
 3e4:	b940fba0 	ldr	w0, [x29, #248]
 3e8:	71003c1f 	cmp	w0, #0xf
 3ec:	54fffd2d 	b.le	390 <sbbb+0x68>
	for (i = 0; i < 6; i++) {
 3f0:	b940ffa0 	ldr	w0, [x29, #252]
 3f4:	11000400 	add	w0, w0, #0x1
 3f8:	b900ffa0 	str	w0, [x29, #252]
 3fc:	b940ffa0 	ldr	w0, [x29, #252]
 400:	7100141f 	cmp	w0, #0x5
 404:	54fffc2d 	b.le	388 <sbbb+0x60>
		}
	}
	
	ptr = (char *)&ft;
 408:	9101e3a0 	add	x0, x29, #0x78
 40c:	f90077a0 	str	x0, [x29, #232]
	for (i = 0; i < 100; i++)
 410:	b900ffbf 	str	wzr, [x29, #252]
 414:	1400000c 	b	444 <sbbb+0x11c>
		printf("%5d", *ptr++);
 418:	f94077a0 	ldr	x0, [x29, #232]
 41c:	91000401 	add	x1, x0, #0x1
 420:	f90077a1 	str	x1, [x29, #232]
 424:	39400000 	ldrb	w0, [x0]
 428:	2a0003e1 	mov	w1, w0
 42c:	90000000 	adrp	x0, 0 <test>
 430:	91000000 	add	x0, x0, #0x0
 434:	94000000 	bl	0 <printf>
	for (i = 0; i < 100; i++)
 438:	b940ffa0 	ldr	w0, [x29, #252]
 43c:	11000400 	add	w0, w0, #0x1
 440:	b900ffa0 	str	w0, [x29, #252]
 444:	b940ffa0 	ldr	w0, [x29, #252]
 448:	71018c1f 	cmp	w0, #0x63
 44c:	54fffe6d 	b.le	418 <sbbb+0xf0>
		
	putchar(0xd);
 450:	528001a0 	mov	w0, #0xd                   	// #13
 454:	94000000 	bl	0 <putchar>
		
	return 0;
 458:	52800000 	mov	w0, #0x0                   	// #0
}
 45c:	a8d07bfd 	ldp	x29, x30, [sp], #256
 460:	d65f03c0 	ret

0000000000000464 <sccc>:
	int count;
	char something[20];
}stu[3] = {{12, 13, "esp"}, {15,16, "sk"}, {17, 18, "we"}};

int sccc()
{
 464:	a9be7bfd 	stp	x29, x30, [sp, #-32]!
 468:	910003fd 	mov	x29, sp
	struct ec *p;
	
	p = stu;
 46c:	90000000 	adrp	x0, 38 <test+0x38>
 470:	91000000 	add	x0, x0, #0x0
 474:	f9000fa0 	str	x0, [x29, #24]
	//p = (struct ec *) &stu[0].num;
	//printf("%d\n", p);
	//printf("%d\n", p + 1);
	
	p = (struct ec *) &stu[0];
 478:	90000000 	adrp	x0, 38 <test+0x38>
 47c:	91000000 	add	x0, x0, #0x0
 480:	f9000fa0 	str	x0, [x29, #24]
	printf("%d\t%d\t%s\n", p->num, p->count, p->something);
 484:	f9400fa0 	ldr	x0, [x29, #24]
 488:	b9400001 	ldr	w1, [x0]
 48c:	f9400fa0 	ldr	x0, [x29, #24]
 490:	b9400402 	ldr	w2, [x0, #4]
 494:	f9400fa0 	ldr	x0, [x29, #24]
 498:	91002003 	add	x3, x0, #0x8
 49c:	90000000 	adrp	x0, 0 <test>
 4a0:	91000000 	add	x0, x0, #0x0
 4a4:	94000000 	bl	0 <printf>
	printf("%d\t%d\t%s\n", (p+1)->num, (p+1)->count, (p+1)->something);
 4a8:	f9400fa0 	ldr	x0, [x29, #24]
 4ac:	91007000 	add	x0, x0, #0x1c
 4b0:	b9400001 	ldr	w1, [x0]
 4b4:	f9400fa0 	ldr	x0, [x29, #24]
 4b8:	91007000 	add	x0, x0, #0x1c
 4bc:	b9400402 	ldr	w2, [x0, #4]
 4c0:	f9400fa0 	ldr	x0, [x29, #24]
 4c4:	91007000 	add	x0, x0, #0x1c
 4c8:	91002003 	add	x3, x0, #0x8
 4cc:	90000000 	adrp	x0, 0 <test>
 4d0:	91000000 	add	x0, x0, #0x0
 4d4:	94000000 	bl	0 <printf>
	
	return 0;
 4d8:	52800000 	mov	w0, #0x0                   	// #0
}
 4dc:	a8c27bfd 	ldp	x29, x30, [sp], #32
 4e0:	d65f03c0 	ret

00000000000004e4 <print>:
}A;

A tmp = {10, '0'};

void print(void)
{
 4e4:	a9bf7bfd 	stp	x29, x30, [sp, #-16]!
 4e8:	910003fd 	mov	x29, sp
        printf("tmp.a = %d tmp.b = %c\n", tmp.a, tmp.b);
 4ec:	90000000 	adrp	x0, 90 <test+0x90>
 4f0:	91000000 	add	x0, x0, #0x0
 4f4:	b9400001 	ldr	w1, [x0]
 4f8:	90000000 	adrp	x0, 90 <test+0x90>
 4fc:	91000000 	add	x0, x0, #0x0
 500:	39401000 	ldrb	w0, [x0, #4]
 504:	2a0003e2 	mov	w2, w0
 508:	90000000 	adrp	x0, 0 <test>
 50c:	91000000 	add	x0, x0, #0x0
 510:	94000000 	bl	0 <printf>

        printf("&tmp = %p &tmp.a = %p &tmp.b = %p\n", 
 514:	90000000 	adrp	x0, 90 <test+0x90>
 518:	91000001 	add	x1, x0, #0x0
 51c:	90000000 	adrp	x0, 90 <test+0x90>
 520:	91000002 	add	x2, x0, #0x0
 524:	90000000 	adrp	x0, 90 <test+0x90>
 528:	91000003 	add	x3, x0, #0x0
 52c:	90000000 	adrp	x0, 0 <test>
 530:	91000000 	add	x0, x0, #0x0
 534:	94000000 	bl	0 <printf>
                        (unsigned long)(void *)&tmp, 
                        (unsigned long)(void *)&tmp.a,
                        (unsigned long)(void *)&tmp.b);

        printf("sizeof tmp = %d sizeof tmp.a = %d sizeof tmp.b = %d\n", 
 538:	90000000 	adrp	x0, 0 <test>
 53c:	91000000 	add	x0, x0, #0x0
 540:	d2800023 	mov	x3, #0x1                   	// #1
 544:	d2800082 	mov	x2, #0x4                   	// #4
 548:	d2800101 	mov	x1, #0x8                   	// #8
 54c:	94000000 	bl	0 <printf>
                        sizeof(A),
                        sizeof(int),
                        sizeof(char));
}
 550:	d503201f 	nop
 554:	a8c17bfd 	ldp	x29, x30, [sp], #16
 558:	d65f03c0 	ret

000000000000055c <priBit>:

void priBit(int t)
{
 55c:	a9bd7bfd 	stp	x29, x30, [sp, #-48]!
 560:	910003fd 	mov	x29, sp
 564:	b9001fa0 	str	w0, [x29, #28]
        int i = 32;
 568:	52800400 	mov	w0, #0x20                  	// #32
 56c:	b9002fa0 	str	w0, [x29, #44]

        printf("t = %d\n", t);
 570:	90000000 	adrp	x0, 0 <test>
 574:	91000000 	add	x0, x0, #0x0
 578:	b9401fa1 	ldr	w1, [x29, #28]
 57c:	94000000 	bl	0 <printf>
        for (; i > 0; i--)
 580:	1400000b 	b	5ac <priBit+0x50>
        {
                printf("%d", (t >> i) & 0x0001);
 584:	b9402fa0 	ldr	w0, [x29, #44]
 588:	b9401fa1 	ldr	w1, [x29, #28]
 58c:	1ac02820 	asr	w0, w1, w0
 590:	12000001 	and	w1, w0, #0x1
 594:	90000000 	adrp	x0, 0 <test>
 598:	91000000 	add	x0, x0, #0x0
 59c:	94000000 	bl	0 <printf>
        for (; i > 0; i--)
 5a0:	b9402fa0 	ldr	w0, [x29, #44]
 5a4:	51000400 	sub	w0, w0, #0x1
 5a8:	b9002fa0 	str	w0, [x29, #44]
 5ac:	b9402fa0 	ldr	w0, [x29, #44]
 5b0:	7100001f 	cmp	w0, #0x0
 5b4:	54fffe8c 	b.gt	584 <priBit+0x28>
        }
        printf("\n");
 5b8:	52800140 	mov	w0, #0xa                   	// #10
 5bc:	94000000 	bl	0 <putchar>
}
 5c0:	d503201f 	nop
 5c4:	a8c37bfd 	ldp	x29, x30, [sp], #48
 5c8:	d65f03c0 	ret

00000000000005cc <_main>:

int _main()
{
 5cc:	a9be7bfd 	stp	x29, x30, [sp, #-32]!
 5d0:	910003fd 	mov	x29, sp
        int *p = NULL;
 5d4:	f9000fbf 	str	xzr, [x29, #24]

        print();
 5d8:	94000000 	bl	4e4 <print>
        p = (int *)&tmp;
 5dc:	90000000 	adrp	x0, 90 <test+0x90>
 5e0:	91000000 	add	x0, x0, #0x0
 5e4:	f9000fa0 	str	x0, [x29, #24]
        priBit(*p);
 5e8:	f9400fa0 	ldr	x0, [x29, #24]
 5ec:	b9400000 	ldr	w0, [x0]
 5f0:	94000000 	bl	55c <priBit>
        priBit(*(p + 1));
 5f4:	f9400fa0 	ldr	x0, [x29, #24]
 5f8:	91001000 	add	x0, x0, #0x4
 5fc:	b9400000 	ldr	w0, [x0]
 600:	94000000 	bl	55c <priBit>
}
 604:	d503201f 	nop
 608:	a8c27bfd 	ldp	x29, x30, [sp], #32
 60c:	d65f03c0 	ret

0000000000000610 <m_ain>:
        char name[20];
        int num;
};

int m_ain()
{
 610:	a9bd7bfd 	stp	x29, x30, [sp, #-48]!
 614:	910003fd 	mov	x29, sp
        void *p = NULL;
 618:	f90017bf 	str	xzr, [x29, #40]
        struct stu a={"li main",5};
 61c:	90000000 	adrp	x0, 0 <test>
 620:	91000000 	add	x0, x0, #0x0
 624:	910043a2 	add	x2, x29, #0x10
 628:	aa0003e3 	mov	x3, x0
 62c:	a9400460 	ldp	x0, x1, [x3]
 630:	a9000440 	stp	x0, x1, [x2]
 634:	f9400860 	ldr	x0, [x3, #16]
 638:	f9000840 	str	x0, [x2, #16]
        p=&a;
 63c:	910043a0 	add	x0, x29, #0x10
 640:	f90017a0 	str	x0, [x29, #40]
        printf(" %s %d  \n",( (struct stu *) p )->name,( (struct stu *) p )->num);
 644:	f94017a1 	ldr	x1, [x29, #40]
 648:	f94017a0 	ldr	x0, [x29, #40]
 64c:	b9401402 	ldr	w2, [x0, #20]
 650:	90000000 	adrp	x0, 0 <test>
 654:	91000000 	add	x0, x0, #0x0
 658:	94000000 	bl	0 <printf>

		_main();
 65c:	94000000 	bl	5cc <_main>

		return 0;
 660:	52800000 	mov	w0, #0x0                   	// #0
}
 664:	a8c37bfd 	ldp	x29, x30, [sp], #48
 668:	d65f03c0 	ret

000000000000066c <main>:

int main()
{
 66c:	a9bc7bfd 	stp	x29, x30, [sp, #-64]!
 670:	910003fd 	mov	x29, sp
	char buf[30];
	
	memset(buf, '0', sizeof(buf));
 674:	910063a0 	add	x0, x29, #0x18
 678:	d28003c2 	mov	x2, #0x1e                  	// #30
 67c:	52800601 	mov	w1, #0x30                  	// #48
 680:	94000000 	bl	0 <memset>
	strcpy(buf,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 684:	910063a2 	add	x2, x29, #0x18
 688:	90000000 	adrp	x0, 0 <test>
 68c:	91000001 	add	x1, x0, #0x0
 690:	aa0203e0 	mov	x0, x2
 694:	a9400c22 	ldp	x2, x3, [x1]
 698:	a9000c02 	stp	x2, x3, [x0]
 69c:	f9400822 	ldr	x2, [x1, #16]
 6a0:	f9000802 	str	x2, [x0, #16]
 6a4:	b8417021 	ldur	w1, [x1, #23]
 6a8:	b8017001 	stur	w1, [x0, #23]
	
	printf("buf length : %d\n", sizeof(buf));	// 30
 6ac:	90000000 	adrp	x0, 0 <test>
 6b0:	91000000 	add	x0, x0, #0x0
 6b4:	d28003c1 	mov	x1, #0x1e                  	// #30
 6b8:	94000000 	bl	0 <printf>
	printf("struct length : %d\n", sizeof(struct aaa));	// 16
 6bc:	90000000 	adrp	x0, 0 <test>
 6c0:	91000000 	add	x0, x0, #0x0
 6c4:	d2800201 	mov	x1, #0x10                  	// #16
 6c8:	94000000 	bl	0 <printf>
	
	aaa *aa;
	aa = (struct aaa*)buf;
 6cc:	910063a0 	add	x0, x29, #0x18
 6d0:	f9001fa0 	str	x0, [x29, #56]
	
	printf("a1 is %d\n", aa->a1);
 6d4:	f9401fa0 	ldr	x0, [x29, #56]
 6d8:	39400000 	ldrb	w0, [x0]
 6dc:	2a0003e1 	mov	w1, w0
 6e0:	90000000 	adrp	x0, 0 <test>
 6e4:	91000000 	add	x0, x0, #0x0
 6e8:	94000000 	bl	0 <printf>
	printf("a2 is %d\n", aa->a2);
 6ec:	f9401fa0 	ldr	x0, [x29, #56]
 6f0:	39400400 	ldrb	w0, [x0, #1]
 6f4:	2a0003e1 	mov	w1, w0
 6f8:	90000000 	adrp	x0, 0 <test>
 6fc:	91000000 	add	x0, x0, #0x0
 700:	94000000 	bl	0 <printf>
	printf("a3 is %s\n", aa->a3);		// why not overflow, xiaozhi?
 704:	f9401fa0 	ldr	x0, [x29, #56]
 708:	91000801 	add	x1, x0, #0x2
 70c:	90000000 	adrp	x0, 0 <test>
 710:	91000000 	add	x0, x0, #0x0
 714:	94000000 	bl	0 <printf>
	printf("a4 is %s\n", aa->a4);		// ditto
 718:	f9401fa0 	ldr	x0, [x29, #56]
 71c:	91002001 	add	x1, x0, #0x8
 720:	90000000 	adrp	x0, 0 <test>
 724:	91000000 	add	x0, x0, #0x0
 728:	94000000 	bl	0 <printf>
	printf("a3 is %.6s\n", aa->a3);
 72c:	f9401fa0 	ldr	x0, [x29, #56]
 730:	91000801 	add	x1, x0, #0x2
 734:	90000000 	adrp	x0, 0 <test>
 738:	91000000 	add	x0, x0, #0x0
 73c:	94000000 	bl	0 <printf>
	printf("a4 is %.8s\n", aa->a4);
 740:	f9401fa0 	ldr	x0, [x29, #56]
 744:	91002001 	add	x1, x0, #0x8
 748:	90000000 	adrp	x0, 0 <test>
 74c:	91000000 	add	x0, x0, #0x0
 750:	94000000 	bl	0 <printf>

	saaa();
 754:	94000000 	bl	300 <saaa>
	
	return 0;
 758:	52800000 	mov	w0, #0x0                   	// #0
}
 75c:	a8c47bfd 	ldp	x29, x30, [sp], #64
 760:	d65f03c0 	ret
